/*
 * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Unlicense OR CC0-1.0
 */

/* esptool.py --chip esp32c2 merge_bin -o esp32c2_at_ble_spp.bin "@flash_args" */

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "esp_bt.h"
#include "driver/uart.h"
#include "string.h"

#include "esp_gap_ble_api.h"
#include "esp_gatts_api.h"
#include "esp_bt_defs.h"
#include "esp_bt_main.h"
#include "esp_bt_device.h"
#include "ble_spp_server.h"
#include "esp_gatt_common_api.h"

#include "soc/gpio_num.h"

#define GATTS_TABLE_TAG "GATTS_SPP"

#define SPP_PROFILE_NUM 1
#define SPP_PROFILE_APP_IDX 0
#define ESP_SPP_APP_ID 0x56
#define SAMPLE_DEVICE_NAME "ESP_SPP_SERVER" // The Device Name Characteristics in GAP
#define SPP_SVC_INST_ID 0

#define UART_BAUD (460800)

/// SPP Service
static const uint16_t spp_service_uuid = 0xFFF0;
/// Characteristic UUID
#define ESP_GATT_UUID_SPP_DATA_RECEIVE 0xFFF2
#define ESP_GATT_UUID_SPP_DATA_NOTIFY 0xFFF1
#define ESP_GATT_UUID_SPP_COMMAND_RECEIVE 0xFFF4
#define ESP_GATT_UUID_SPP_COMMAND_NOTIFY 0xFFF3

#ifdef SUPPORT_HEARTBEAT
#define ESP_GATT_UUID_SPP_HEARTBEAT 0xABF5
#endif

static uint8_t spp_adv_data_prefix[9] = {
    /* Flags */
    0x02,
    0x01,
    0x06,
    /* Complete List of 16-bit Service Class UUIDs */
    0x03,
    0x03,
    0xCD,
    0xAB,
    /* Complete Local Name in advertising */
    0x00,
    0x09,
};

static char spp_adv_name[32] = "UCCHIP-GW";
static uint8_t *spp_adv_data = NULL;

static uint16_t spp_mtu_size = 23;
static uint16_t spp_conn_id = 0xffff;
static esp_gatt_if_t spp_gatts_if = 0xff;
QueueHandle_t at_uart_queue = NULL;
QueueHandle_t spp_uart_queue = NULL;
static QueueHandle_t cmd_cmd_queue = NULL;

static uint8_t is_entry_spp_mode = false;

#ifdef SUPPORT_HEARTBEAT
static QueueHandle_t cmd_heartbeat_queue = NULL;
static uint8_t heartbeat_s[9] = {'E', 's', 'p', 'r', 'e', 's', 's', 'i', 'f'};
static bool enable_heart_ntf = false;
static uint8_t heartbeat_count_num = 0;
#endif

static bool enable_data_ntf = false;
static bool is_connected = false;
static esp_bd_addr_t spp_remote_bda = {
    0x0,
};

static uint16_t spp_handle_table[SPP_IDX_NB];

static esp_ble_adv_params_t spp_adv_params = {
    .adv_int_min = 0x20,
    .adv_int_max = 0x40,
    .adv_type = ADV_TYPE_IND,
    .own_addr_type = BLE_ADDR_TYPE_PUBLIC,
    .channel_map = ADV_CHNL_ALL,
    .adv_filter_policy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY,
};

struct gatts_profile_inst
{
    esp_gatts_cb_t gatts_cb;
    uint16_t gatts_if;
    uint16_t app_id;
    uint16_t conn_id;
    uint16_t service_handle;
    esp_gatt_srvc_id_t service_id;
    uint16_t char_handle;
    esp_bt_uuid_t char_uuid;
    esp_gatt_perm_t perm;
    esp_gatt_char_prop_t property;
    uint16_t descr_handle;
    esp_bt_uuid_t descr_uuid;
};

typedef struct spp_receive_data_node
{
    int32_t len;
    uint8_t *node_buff;
    struct spp_receive_data_node *next_node;
} spp_receive_data_node_t;

static spp_receive_data_node_t *temp_spp_recv_data_node_p1 = NULL;
static spp_receive_data_node_t *temp_spp_recv_data_node_p2 = NULL;

typedef struct spp_receive_data_buff
{
    int32_t node_num;
    int32_t buff_size;
    spp_receive_data_node_t *first_node;
} spp_receive_data_buff_t;

static spp_receive_data_buff_t SppRecvDataBuff = {
    .node_num = 0,
    .buff_size = 0,
    .first_node = NULL};

static void gatts_profile_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param);

/* One gatt-based profile one app_id and one gatts_if, this array will store the gatts_if returned by ESP_GATTS_REG_EVT */
static struct gatts_profile_inst spp_profile_tab[SPP_PROFILE_NUM] = {
    [SPP_PROFILE_APP_IDX] = {
        .gatts_cb = gatts_profile_event_handler,
        .gatts_if = ESP_GATT_IF_NONE, /* Not get the gatt_if, so initial is ESP_GATT_IF_NONE */
    },
};

/*
 *  SPP PROFILE ATTRIBUTES
 ****************************************************************************************
 */

#define CHAR_DECLARATION_SIZE (sizeof(uint8_t))
static const uint16_t primary_service_uuid = ESP_GATT_UUID_PRI_SERVICE;
static const uint16_t character_declaration_uuid = ESP_GATT_UUID_CHAR_DECLARE;
static const uint16_t character_client_config_uuid = ESP_GATT_UUID_CHAR_CLIENT_CONFIG;

static const uint8_t char_prop_read_notify = ESP_GATT_CHAR_PROP_BIT_READ | ESP_GATT_CHAR_PROP_BIT_NOTIFY;
static const uint8_t char_prop_read_write = ESP_GATT_CHAR_PROP_BIT_WRITE_NR | ESP_GATT_CHAR_PROP_BIT_READ;

#ifdef SUPPORT_HEARTBEAT
static const uint8_t char_prop_read_write_notify = ESP_GATT_CHAR_PROP_BIT_READ | ESP_GATT_CHAR_PROP_BIT_WRITE_NR | ESP_GATT_CHAR_PROP_BIT_NOTIFY;
#endif

/// SPP Service - data receive characteristic, read&write without response
static const uint16_t spp_data_receive_uuid = ESP_GATT_UUID_SPP_DATA_RECEIVE;
static const uint8_t spp_data_receive_val[20] = {0x00};

/// SPP Service - data notify characteristic, notify&read
static const uint16_t spp_data_notify_uuid = ESP_GATT_UUID_SPP_DATA_NOTIFY;
static const uint8_t spp_data_notify_val[20] = {0x00};
static const uint8_t spp_data_notify_ccc[2] = {0x00, 0x00};

/// SPP Service - command characteristic, read&write without response
static const uint16_t spp_command_uuid = ESP_GATT_UUID_SPP_COMMAND_RECEIVE;
static const uint8_t spp_command_val[10] = {0x00};

/// SPP Service - status characteristic, notify&read
static const uint16_t spp_status_uuid = ESP_GATT_UUID_SPP_COMMAND_NOTIFY;
static const uint8_t spp_status_val[10] = {0x00};
static const uint8_t spp_status_ccc[2] = {0x00, 0x00};

#ifdef SUPPORT_HEARTBEAT
/// SPP Server - Heart beat characteristic, notify&write&read
static const uint16_t spp_heart_beat_uuid = ESP_GATT_UUID_SPP_HEARTBEAT;
static const uint8_t spp_heart_beat_val[2] = {0x00, 0x00};
static const uint8_t spp_heart_beat_ccc[2] = {0x00, 0x00};
#endif

/// Full HRS Database Description - Used to add attributes into the database
static const esp_gatts_attr_db_t spp_gatt_db[SPP_IDX_NB] =
    {
        // SPP -  Service Declaration
        [SPP_IDX_SVC] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ, sizeof(spp_service_uuid), sizeof(spp_service_uuid), (uint8_t *)&spp_service_uuid}},

        // SPP -  data receive characteristic Declaration
        [SPP_IDX_SPP_DATA_RECV_CHAR] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write}},

        // SPP -  data receive characteristic Value
        [SPP_IDX_SPP_DATA_RECV_VAL] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_data_receive_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, SPP_DATA_MAX_LEN, sizeof(spp_data_receive_val), (uint8_t *)spp_data_receive_val}},

        // SPP -  data notify characteristic Declaration
        [SPP_IDX_SPP_DATA_NOTIFY_CHAR] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_notify}},

        // SPP -  data notify characteristic Value
        [SPP_IDX_SPP_DATA_NTY_VAL] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_data_notify_uuid, ESP_GATT_PERM_READ, SPP_DATA_MAX_LEN, sizeof(spp_data_notify_val), (uint8_t *)spp_data_notify_val}},

        // SPP -  data notify characteristic - Client Characteristic Configuration Descriptor
        [SPP_IDX_SPP_DATA_NTF_CFG] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(spp_data_notify_ccc), (uint8_t *)spp_data_notify_ccc}},

        // SPP -  command characteristic Declaration
        [SPP_IDX_SPP_COMMAND_CHAR] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write}},

        // SPP -  command characteristic Value
        [SPP_IDX_SPP_COMMAND_VAL] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_command_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, SPP_CMD_MAX_LEN, sizeof(spp_command_val), (uint8_t *)spp_command_val}},

        // SPP -  status characteristic Declaration
        [SPP_IDX_SPP_STATUS_CHAR] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_notify}},

        // SPP -  status characteristic Value
        [SPP_IDX_SPP_STATUS_VAL] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_status_uuid, ESP_GATT_PERM_READ, SPP_STATUS_MAX_LEN, sizeof(spp_status_val), (uint8_t *)spp_status_val}},

        // SPP -  status characteristic - Client Characteristic Configuration Descriptor
        [SPP_IDX_SPP_STATUS_CFG] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(spp_status_ccc), (uint8_t *)spp_status_ccc}},

#ifdef SUPPORT_HEARTBEAT
        // SPP -  Heart beat characteristic Declaration
        [SPP_IDX_SPP_HEARTBEAT_CHAR] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ, CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_write_notify}},

        // SPP -  Heart beat characteristic Value
        [SPP_IDX_SPP_HEARTBEAT_VAL] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&spp_heart_beat_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(spp_heart_beat_val), sizeof(spp_heart_beat_val), (uint8_t *)spp_heart_beat_val}},

        // SPP -  Heart beat characteristic - Client Characteristic Configuration Descriptor
        [SPP_IDX_SPP_HEARTBEAT_CFG] =
            {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE, sizeof(uint16_t), sizeof(spp_data_notify_ccc), (uint8_t *)spp_heart_beat_ccc}},
#endif
};

static uint8_t find_char_and_desr_index(uint16_t handle)
{
    uint8_t error = 0xff;

    for (int i = 0; i < SPP_IDX_NB; i++)
    {
        if (handle == spp_handle_table[i])
        {
            return i;
        }
    }

    return error;
}

static bool store_wr_buffer(esp_ble_gatts_cb_param_t *p_data)
{
    temp_spp_recv_data_node_p1 = (spp_receive_data_node_t *)malloc(sizeof(spp_receive_data_node_t));

    if (temp_spp_recv_data_node_p1 == NULL)
    {
        ESP_LOGI(GATTS_TABLE_TAG, "malloc error %s %d", __func__, __LINE__);
        return false;
    }
    if (temp_spp_recv_data_node_p2 != NULL)
    {
        temp_spp_recv_data_node_p2->next_node = temp_spp_recv_data_node_p1;
    }
    temp_spp_recv_data_node_p1->len = p_data->write.len;
    SppRecvDataBuff.buff_size += p_data->write.len;
    temp_spp_recv_data_node_p1->next_node = NULL;
    temp_spp_recv_data_node_p1->node_buff = (uint8_t *)malloc(p_data->write.len);
    temp_spp_recv_data_node_p2 = temp_spp_recv_data_node_p1;
    if (temp_spp_recv_data_node_p1->node_buff == NULL)
    {
        ESP_LOGI(GATTS_TABLE_TAG, "malloc error %s %d\n", __func__, __LINE__);
        temp_spp_recv_data_node_p1->len = 0;
    }
    else
    {
        memcpy(temp_spp_recv_data_node_p1->node_buff, p_data->write.value, p_data->write.len);
    }

    if (SppRecvDataBuff.node_num == 0)
    {
        SppRecvDataBuff.first_node = temp_spp_recv_data_node_p1;
        SppRecvDataBuff.node_num++;
    }
    else
    {
        SppRecvDataBuff.node_num++;
    }

    return true;
}

static void free_write_buffer(void)
{
    temp_spp_recv_data_node_p1 = SppRecvDataBuff.first_node;

    while (temp_spp_recv_data_node_p1 != NULL)
    {
        temp_spp_recv_data_node_p2 = temp_spp_recv_data_node_p1->next_node;
        if (temp_spp_recv_data_node_p1->node_buff)
        {
            free(temp_spp_recv_data_node_p1->node_buff);
        }
        free(temp_spp_recv_data_node_p1);
        temp_spp_recv_data_node_p1 = temp_spp_recv_data_node_p2;
    }

    SppRecvDataBuff.node_num = 0;
    SppRecvDataBuff.buff_size = 0;
    SppRecvDataBuff.first_node = NULL;
}

static void print_write_buffer(void)
{
    temp_spp_recv_data_node_p1 = SppRecvDataBuff.first_node;

    while (temp_spp_recv_data_node_p1 != NULL)
    {
        uart_write_bytes(UART_NUM_1, (char *)(temp_spp_recv_data_node_p1->node_buff), temp_spp_recv_data_node_p1->len);
        temp_spp_recv_data_node_p1 = temp_spp_recv_data_node_p1->next_node;
    }
}

void uart_task(void *pvParameters)
{
    uart_event_t event;
    uint8_t total_num = 0;
    uint8_t current_num = 0;
    uint8_t *uart_read_buffer = (uint8_t *)malloc(sizeof(uint8_t) * 4096);
    uint8_t *ntf_value_p = (uint8_t *)malloc(sizeof(uint8_t) * 1024);

    for (;;)
    {
        // Waiting for UART event.
        if (xQueueReceive(spp_uart_queue, (void *)&event, (TickType_t)portMAX_DELAY))
        {
            switch (event.type)
            {
            // Event of UART receiving data
            case UART_DATA:
                if (event.size)
                {
                    memset(uart_read_buffer, 0x0, event.size);
                    uart_read_bytes(UART_NUM_1, uart_read_buffer, event.size, portMAX_DELAY);
                    if (is_connected == false)
                    {
                        break;
                    }

#ifdef SUPPORT_HEARTBEAT
                    if (!enable_heart_ntf)
                    {
                        ESP_LOGE(GATTS_TABLE_TAG, "%s do not enable heartbeat Notify", __func__);
                        break;
                    }
#endif
                    if (!enable_data_ntf)
                    {
                        ESP_LOGE(GATTS_TABLE_TAG, "%s do not enable data Notify", __func__);
                        break;
                    }
                    if (event.size <= (spp_mtu_size - 3))
                    {
                        esp_ble_gatts_send_indicate(spp_gatts_if, spp_conn_id, spp_handle_table[SPP_IDX_SPP_DATA_NTY_VAL], event.size, uart_read_buffer, false);
                    }
                    else if (event.size > (spp_mtu_size - 3))
                    {
                        if ((event.size % (spp_mtu_size - 7)) == 0)
                        {
                            total_num = event.size / (spp_mtu_size - 7);
                        }
                        else
                        {
                            total_num = event.size / (spp_mtu_size - 7) + 1;
                        }
                        current_num = 1;
                        while (current_num <= total_num)
                        {
                            if (current_num < total_num)
                            {
                                ntf_value_p[0] = '#';
                                ntf_value_p[1] = '#';
                                ntf_value_p[2] = total_num;
                                ntf_value_p[3] = current_num;
                                memcpy(ntf_value_p + 4, uart_read_buffer + (current_num - 1) * (spp_mtu_size - 7), (spp_mtu_size - 7));
                                esp_ble_gatts_send_indicate(spp_gatts_if, spp_conn_id, spp_handle_table[SPP_IDX_SPP_DATA_NTY_VAL], (spp_mtu_size - 3), ntf_value_p, false);
                            }
                            else if (current_num == total_num)
                            {
                                ntf_value_p[0] = '#';
                                ntf_value_p[1] = '#';
                                ntf_value_p[2] = total_num;
                                ntf_value_p[3] = current_num;
                                memcpy(ntf_value_p + 4, uart_read_buffer + (current_num - 1) * (spp_mtu_size - 7), (event.size - (current_num - 1) * (spp_mtu_size - 7)));
                                esp_ble_gatts_send_indicate(spp_gatts_if, spp_conn_id, spp_handle_table[SPP_IDX_SPP_DATA_NTY_VAL], (event.size - (current_num - 1) * (spp_mtu_size - 7) + 4), ntf_value_p, false);
                            }
                            vTaskDelay(20 / portTICK_PERIOD_MS);
                            current_num++;
                        }
                    }
                }
                break;
            default:
                break;
            }
        }
    }
    free(uart_read_buffer);
    free(ntf_value_p);
    vTaskDelete(NULL);
}

static void spp_uart_init(void)
{
    uart_config_t uart_config = {
        .baud_rate = UART_BAUD,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .rx_flow_ctrl_thresh = 122,
        .source_clk = UART_SCLK_XTAL,
    };

    // Install UART driver, and get the queue.
    uart_driver_install(UART_NUM_1, 4096, 8192, 10, &spp_uart_queue, 0);
    // Set UART parameters
    uart_param_config(UART_NUM_1, &uart_config);
    // Set UART pins
    uart_set_pin(UART_NUM_1, GPIO_NUM_7, GPIO_NUM_6, GPIO_NUM_4, GPIO_NUM_5);
    xTaskCreate(uart_task, "uTask", 2048, (void *)UART_NUM_1, 8, NULL);
}

enum
{
    AT_CMD_BLEADDR = 0,
    AT_CMD_RFPOWER,
    AT_CMD_BLEADVDATAEX,
    AT_CMD_BLESPP,
    AT_CMD_MAX
};

const char AT_BLEADDR[] = "AT+BLEADDR?";
const char AT_BLEADDR_RES[] = "+BLEADDR:";

const char AT_RFPOWER[] = "AT+RFPOWER";
const char AT_RFPOWER_RES[] = "+RFPOWER:";

const char AT_BLEADVDATAEX[] = "AT+BLEADVDATAEX";
const char AT_BLEADVDATAEX_RES[] = " ";

const char AT_BLESPP[] = "AT+BLESPP";
const char AT_BLESPP_RES[] = " ";

const char AT_START[] = "AT+";
const char AT_END[] = "\r\n";
const char AT_ERROR[] = "ERROR\r\n";
const char AT_OK[] = "OK\r\n";
const char AT_READY[] = "ready\r\n";
const char AT_SPP_ENTRY[] = "\r\n>\r\n";

const char ESP_LOG_AT_TAG[] = "AT_CMD";

#define AT_CMD_BUFFER_SIZE (64)
static uint8_t at_cmd_buffer[AT_CMD_BUFFER_SIZE];
static uint8_t at_cmd_state = 0;
static uint8_t at_cmd_index = 0;
static uint8_t at_cmd_exit_flag = false;

typedef struct
{
    uint8_t cmd_type;
    const char *cmd_str;
    const char *cmd_res_str;
    int (*cmd_exec)(uint8_t at_cmd_table_index, uint8_t *data);
} at_cmd_t;

enum
{
    AT_CMD_STATE_RECV_START_A,
    AT_CMD_STATE_RECV_START_T,
    AT_CMD_STATE_RECV_START_PLUS,
    AT_CMD_STATE_RECV_END,
    AT_CMD_STATE_RECV_CMD,
    AT_CMD_STATE_RECV_ERROR,
    AT_CMD_STATE_RECV_COMPLETE,
    AT_CMD_STATE_RECV_TEST,
};

static int at_cmd_bleaddr_exec(uint8_t at_cmd_table_index, uint8_t *data);
static int at_cmd_rfpower_exec(uint8_t at_cmd_table_index, uint8_t *data);
static int at_cmd_bleadvdataex_exec(uint8_t at_cmd_table_index, uint8_t *data);
static int at_cmd_blespp_exec(uint8_t at_cmd_table_index, uint8_t *data);

at_cmd_t at_cmd_table[AT_CMD_MAX] = {
    {AT_CMD_BLEADDR, AT_BLEADDR, AT_BLEADDR_RES, at_cmd_bleaddr_exec},
    {AT_CMD_RFPOWER, AT_RFPOWER, AT_RFPOWER_RES, at_cmd_rfpower_exec},
    {AT_CMD_BLEADVDATAEX, AT_BLEADVDATAEX, AT_BLEADVDATAEX_RES, at_cmd_bleadvdataex_exec},
    {AT_CMD_BLESPP, AT_BLESPP, AT_BLESPP_RES, at_cmd_blespp_exec},
};

static int at_cmd_respose(const char *resp_prefix, char *buffer)
{
    if (resp_prefix == NULL)
    {
        return ESP_OK;
    }

    char response_buffer[AT_CMD_BUFFER_SIZE];
    memset(response_buffer, 0x0, sizeof(response_buffer));

    if (buffer == NULL)
    {
        sprintf(response_buffer, "%s%s", resp_prefix, AT_END);
    }
    else
    {
        sprintf(response_buffer, "%s%s%s", resp_prefix, buffer, AT_END);
    }
    uart_write_bytes(UART_NUM_1, response_buffer, strlen(response_buffer));
    ESP_LOGI(ESP_LOG_AT_TAG, "%s", response_buffer);

    return ESP_OK;
}

static int at_cmd_bleaddr_exec(uint8_t at_cmd_table_index, uint8_t *data)
{
    if (data[0] == AT_END[0] && data[1] == AT_END[1])
    {
        const uint8_t *ble_addr = esp_bt_dev_get_address();
        char res_buffer[32];
        memset(res_buffer, 0x0, sizeof(res_buffer));
        sprintf((char *)res_buffer, "\"%02x:%02x:%02x:%02x:%02x:%02x\"", ble_addr[0], ble_addr[1], ble_addr[2], ble_addr[3], ble_addr[4], ble_addr[5]);
        at_cmd_respose(at_cmd_table[at_cmd_table_index].cmd_res_str, res_buffer);
        return ESP_OK;
    }

    return ESP_FAIL;
}

static int at_cmd_rfpower_exec(uint8_t at_cmd_table_index, uint8_t *data)
{
    if (data[0] == '?' && data[1] == AT_END[0] && data[2] == AT_END[1])
    {
        esp_power_level_t tx_power = esp_ble_tx_power_get(ESP_BLE_PWR_TYPE_DEFAULT);
        char res_buffer[32];
        memset(res_buffer, 0x0, sizeof(res_buffer));
        sprintf(res_buffer, "%d", tx_power);
        at_cmd_respose(at_cmd_table[at_cmd_table_index].cmd_res_str, res_buffer);
        return ESP_OK;
    }
    else if (data[0] == '=')
    {
        if ((data[2] == AT_END[0] && data[3] == AT_END[1]) ||
            (data[3] == AT_END[0] && data[4] == AT_END[1]))
        {
            int tx_power = 0;
            sscanf((char *)&data[1], "%d\r\n", &tx_power);
            if (tx_power >= ESP_PWR_LVL_N24 && tx_power <= ESP_PWR_LVL_P21)
            {
                esp_ble_tx_power_set(ESP_BLE_PWR_TYPE_DEFAULT, tx_power);
                at_cmd_respose(NULL, NULL);
                return ESP_OK;
            }
        }
    }

    return ESP_FAIL;
}

static int at_cmd_bleadvdataex_exec(uint8_t at_cmd_table_index, uint8_t *data)
{
    char adv_name[32], temp_1[32], temp_2[32];
    int temp_3 = 0;

    if (data[0] == '=')
    {
        memset(adv_name, 0x0, sizeof(adv_name));
        memset(temp_1, 0x0, sizeof(temp_1));
        memset(temp_2, 0x0, sizeof(temp_2));
        sscanf((char *)&data[1], "\"%[^\"]\",\"%[^\"]\",\"%[^\"]\",%d\r\n", adv_name, temp_1, temp_2, &temp_3);

        if (strlen(adv_name) > 0 && strlen(adv_name) <= 20)
        {
            memset(spp_adv_name, 0x0, sizeof(spp_adv_name));
            memcpy(spp_adv_name, adv_name, strlen(adv_name));
            at_cmd_respose(at_cmd_table[at_cmd_table_index].cmd_res_str, NULL);
            return ESP_OK;
        }
    }

    return ESP_FAIL;
}

static int at_cmd_blespp_exec(uint8_t at_cmd_table_index, uint8_t *data)
{
    if (data[0] == AT_END[0] && data[1] == AT_END[1])
    {
        at_cmd_exit_flag = true;
        return ESP_OK;
    }
    return ESP_FAIL;
}

static void at_server_recv_byte(uint8_t data)
{
    if (data >= 'a' && data <= 'z')
    {
        data = data - 'a' + 'A';
    }

    switch (at_cmd_state)
    {
    case AT_CMD_STATE_RECV_START_A:
        if (data == AT_START[0])
        {
            at_cmd_state = AT_CMD_STATE_RECV_START_T;
        }
        break;

    case AT_CMD_STATE_RECV_START_T:
        if (data == AT_START[1])
        {
            at_cmd_state = AT_CMD_STATE_RECV_START_PLUS;
        }
        else
        {
            at_cmd_state = AT_CMD_STATE_RECV_START_A;
        }
        break;

    case AT_CMD_STATE_RECV_START_PLUS:
        if (data == AT_START[2])
        {
            at_cmd_state = AT_CMD_STATE_RECV_CMD;
            memset(at_cmd_buffer, 0x0, sizeof(at_cmd_buffer));
            memcpy(at_cmd_buffer, AT_START, strlen(AT_START));
            at_cmd_index = strlen(AT_START);
        }
        else if (data == AT_END[0])
        {
            at_cmd_state = AT_CMD_STATE_RECV_END;
        }
        else
        {
            at_cmd_state = AT_CMD_STATE_RECV_START_A;
        }
        break;

    case AT_CMD_STATE_RECV_END:
        if (data == AT_END[1])
        {
            at_cmd_state = AT_CMD_STATE_RECV_TEST;
        }
        else
        {
            at_cmd_state = AT_CMD_STATE_RECV_START_A;
        }
        break;

    case AT_CMD_STATE_RECV_CMD:
        at_cmd_buffer[at_cmd_index] = data;
        at_cmd_index += 1;

        if (at_cmd_buffer[at_cmd_index - 2] == AT_END[0] &&
            at_cmd_buffer[at_cmd_index - 1] == AT_END[1])
        {
            at_cmd_state = AT_CMD_STATE_RECV_COMPLETE;
            at_cmd_index = 0;
        }

        if (at_cmd_index >= AT_CMD_BUFFER_SIZE)
        {
            at_cmd_state = AT_CMD_STATE_RECV_ERROR;
            at_cmd_index = 0;
        }
        break;

    default:
        break;
    }
}

uint8_t at_server_cmd_parse(uint8_t *buffer)
{
    uint8_t index = 0;
    for (index = 0; index < AT_CMD_MAX; index++)
    {
        if (strncmp((const char *)buffer, at_cmd_table[index].cmd_str, strlen(at_cmd_table[index].cmd_str)) == 0)
        {
            break;
        }
    }

    return index;
}

void at_server_process(void)
{
    uint8_t at_cmd_table_index = 0;
    uint8_t *data_ptr = NULL;

    switch (at_cmd_state)
    {
    case AT_CMD_STATE_RECV_TEST:
        uart_write_bytes(UART_NUM_1, AT_OK, strlen(AT_OK));
        at_cmd_state = AT_CMD_STATE_RECV_START_A;
        break;

    case AT_CMD_STATE_RECV_COMPLETE:
        at_cmd_table_index = at_server_cmd_parse(at_cmd_buffer);
        if (at_cmd_table_index >= AT_CMD_MAX)
        {
            uart_write_bytes(UART_NUM_1, AT_ERROR, strlen(AT_ERROR));
            at_cmd_state = AT_CMD_STATE_RECV_START_A;
        }
        else
        {
            data_ptr = &at_cmd_buffer[strlen(at_cmd_table[at_cmd_table_index].cmd_str)];
            if ((at_cmd_table[at_cmd_table_index].cmd_exec)(at_cmd_table_index, data_ptr) == ESP_OK)
            {
                uart_write_bytes(UART_NUM_1, AT_OK, strlen(AT_OK));
            }
            else
            {
                uart_write_bytes(UART_NUM_1, AT_ERROR, strlen(AT_ERROR));
            }
        }
        at_cmd_state = AT_CMD_STATE_RECV_START_A;
        break;

    case AT_CMD_STATE_RECV_ERROR:
        uart_write_bytes(UART_NUM_1, AT_ERROR, strlen(AT_ERROR));
        at_cmd_state = AT_CMD_STATE_RECV_START_A;
        break;

    default:
        break;
    }
}

static void at_uart_task(void *pvParameters)
{
    uart_event_t event;

    uart_write_bytes(UART_NUM_1, AT_READY, strlen(AT_READY));

    for (;;)
    {
        // Waiting for UART event.
        if (xQueueReceive(at_uart_queue, (void *)&event, (TickType_t)portMAX_DELAY))
        {
            switch (event.type)
            {
            // Event of UART receiving data
            case UART_DATA:
                if (event.size)
                {
                    uint8_t read_size = 0;
                    uint8_t read_data = 0;
                    for (uint8_t i = 0; i < event.size; i++)
                    {
                        read_size = uart_read_bytes(UART_NUM_1, &read_data, 1, portMAX_DELAY);
                        if (read_size > 0)
                        {
                            at_server_recv_byte(read_data);
                        }
                        else
                        {
                            break;
                        }
                    }
                    at_server_process();
                }
                break;
            default:
                break;
            }
            if (at_cmd_exit_flag == true)
            {
                uart_write_bytes(UART_NUM_1, AT_SPP_ENTRY, strlen(AT_SPP_ENTRY));
                break;
            }
        }
    }
    is_entry_spp_mode = true;
    vTaskDelete(NULL);
}

static void at_uart_init(void)
{
    uart_config_t uart_config = {
        .baud_rate = UART_BAUD,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .rx_flow_ctrl_thresh = 122,
        .source_clk = UART_SCLK_XTAL,
    };

    // Install UART driver, and get the queue.
    uart_driver_install(UART_NUM_1, 4096, 8192, 10, &at_uart_queue, 0);
    // Set UART parameters
    uart_param_config(UART_NUM_1, &uart_config);
    // Set UART pins
    uart_set_pin(UART_NUM_1, GPIO_NUM_7, GPIO_NUM_6, GPIO_NUM_4, GPIO_NUM_5);
    xTaskCreate(at_uart_task, "atuTask", 2048, (void *)UART_NUM_1, 8, NULL);
}

#ifdef SUPPORT_HEARTBEAT
void spp_heartbeat_task(void *arg)
{
    uint16_t cmd_id;

    for (;;)
    {
        vTaskDelay(50 / portTICK_PERIOD_MS);
        if (xQueueReceive(cmd_heartbeat_queue, &cmd_id, portMAX_DELAY))
        {
            while (1)
            {
                heartbeat_count_num++;
                vTaskDelay(5000 / portTICK_PERIOD_MS);
                if ((heartbeat_count_num > 3) && (is_connected))
                {
                    esp_ble_gap_disconnect(spp_remote_bda);
                }
                if (is_connected && enable_heart_ntf)
                {
                    esp_ble_gatts_send_indicate(spp_gatts_if, spp_conn_id, spp_handle_table[SPP_IDX_SPP_HEARTBEAT_VAL], sizeof(heartbeat_s), heartbeat_s, false);
                }
                else if (!is_connected)
                {
                    break;
                }
            }
        }
    }
    vTaskDelete(NULL);
}
#endif

void spp_cmd_task(void *arg)
{
    uint8_t *cmd_id;

    for (;;)
    {
        vTaskDelay(50 / portTICK_PERIOD_MS);
        if (xQueueReceive(cmd_cmd_queue, &cmd_id, portMAX_DELAY))
        {
            esp_log_buffer_char(GATTS_TABLE_TAG, (char *)(cmd_id), strlen((char *)cmd_id));
            free(cmd_id);
        }
    }
    vTaskDelete(NULL);
}

static void spp_task_init(void)
{
    spp_uart_init();

#ifdef SUPPORT_HEARTBEAT
    cmd_heartbeat_queue = xQueueCreate(10, sizeof(uint32_t));
    xTaskCreate(spp_heartbeat_task, "spp_heartbeat_task", 2048, NULL, 10, NULL);
#endif

    cmd_cmd_queue = xQueueCreate(10, sizeof(uint32_t));
    xTaskCreate(spp_cmd_task, "spp_cmd_task", 2048, NULL, 10, NULL);
}

static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
{
    esp_err_t err;
    ESP_LOGI(GATTS_TABLE_TAG, "GAP_EVT, event %d", event);

    switch (event)
    {
    case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT:
        esp_ble_gap_start_advertising(&spp_adv_params);
        break;
    case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
        // advertising start complete event to indicate advertising start successfully or failed
        if ((err = param->adv_start_cmpl.status) != ESP_BT_STATUS_SUCCESS)
        {
            ESP_LOGE(GATTS_TABLE_TAG, "Advertising start failed: %s", esp_err_to_name(err));
        }
        break;
    default:
        break;
    }
}

static void gatts_profile_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param)
{
    esp_ble_gatts_cb_param_t *p_data = (esp_ble_gatts_cb_param_t *)param;
    uint8_t res = 0xff;
    uint8_t spp_adv_data_len = 0;

    ESP_LOGI(GATTS_TABLE_TAG, "event = %x", event);
    switch (event)
    {
    case ESP_GATTS_REG_EVT:
        ESP_LOGI(GATTS_TABLE_TAG, "%s %d", __func__, __LINE__);
        esp_ble_gap_set_device_name(spp_adv_name);

        ESP_LOGI(GATTS_TABLE_TAG, "%s %d", __func__, __LINE__);
        spp_adv_data_len = sizeof(spp_adv_data_prefix) + strlen(spp_adv_name);
        spp_adv_data = (uint8_t *)malloc(spp_adv_data_len);
        spp_adv_data_prefix[7] = strlen(spp_adv_name) + 1;
        memcpy(spp_adv_data, spp_adv_data_prefix, sizeof(spp_adv_data_prefix));
        memcpy(spp_adv_data + sizeof(spp_adv_data_prefix), spp_adv_name, strlen(spp_adv_name));
        esp_ble_gap_config_adv_data_raw((uint8_t *)spp_adv_data, spp_adv_data_len);

        ESP_LOGI(GATTS_TABLE_TAG, "%s %d", __func__, __LINE__);
        esp_ble_gatts_create_attr_tab(spp_gatt_db, gatts_if, SPP_IDX_NB, SPP_SVC_INST_ID);
        break;
    case ESP_GATTS_READ_EVT:
        res = find_char_and_desr_index(p_data->read.handle);
        if (res == SPP_IDX_SPP_STATUS_VAL)
        {
            // TODO:client read the status characteristic
        }
        break;
    case ESP_GATTS_WRITE_EVT:
    {
        res = find_char_and_desr_index(p_data->write.handle);
        if (p_data->write.is_prep == false)
        {
            ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_WRITE_EVT : handle = %d", res);
            if (res == SPP_IDX_SPP_COMMAND_VAL)
            {
                uint8_t *spp_cmd_buff = NULL;
                spp_cmd_buff = (uint8_t *)malloc((spp_mtu_size - 3) * sizeof(uint8_t));
                if (spp_cmd_buff == NULL)
                {
                    ESP_LOGE(GATTS_TABLE_TAG, "%s malloc failed", __func__);
                    break;
                }
                memset(spp_cmd_buff, 0x0, (spp_mtu_size - 3));
                memcpy(spp_cmd_buff, p_data->write.value, p_data->write.len);
                xQueueSend(cmd_cmd_queue, &spp_cmd_buff, 10 / portTICK_PERIOD_MS);
            }
            else if (res == SPP_IDX_SPP_DATA_NTF_CFG)
            {
                if ((p_data->write.len == 2) && (p_data->write.value[0] == 0x01) && (p_data->write.value[1] == 0x00))
                {
                    enable_data_ntf = true;
                }
                else if ((p_data->write.len == 2) && (p_data->write.value[0] == 0x00) && (p_data->write.value[1] == 0x00))
                {
                    enable_data_ntf = false;
                }
            }
#ifdef SUPPORT_HEARTBEAT
            else if (res == SPP_IDX_SPP_HEARTBEAT_CFG)
            {
                if ((p_data->write.len == 2) && (p_data->write.value[0] == 0x01) && (p_data->write.value[1] == 0x00))
                {
                    enable_heart_ntf = true;
                }
                else if ((p_data->write.len == 2) && (p_data->write.value[0] == 0x00) && (p_data->write.value[1] == 0x00))
                {
                    enable_heart_ntf = false;
                }
            }
            else if (res == SPP_IDX_SPP_HEARTBEAT_VAL)
            {
                if ((p_data->write.len == sizeof(heartbeat_s)) && (memcmp(heartbeat_s, p_data->write.value, sizeof(heartbeat_s)) == 0))
                {
                    heartbeat_count_num = 0;
                }
            }
#endif
            else if (res == SPP_IDX_SPP_DATA_RECV_VAL)
            {
#ifdef SPP_DEBUG_MODE
                esp_log_buffer_char(GATTS_TABLE_TAG, (char *)(p_data->write.value), p_data->write.len);
#else
                uart_write_bytes(UART_NUM_1, (char *)(p_data->write.value), p_data->write.len);
#endif
            }
            else
            {
                // TODO:
            }
        }
        else if ((p_data->write.is_prep == true) && (res == SPP_IDX_SPP_DATA_RECV_VAL))
        {
            ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_PREP_WRITE_EVT : handle = %d", res);
            store_wr_buffer(p_data);
        }
        else
        {
            ESP_LOGE(GATTS_TABLE_TAG, "ESP_GATTS_WRITE_EVT error : handle = %d", res);
        }
        break;
    }
    case ESP_GATTS_EXEC_WRITE_EVT:
    {
        ESP_LOGI(GATTS_TABLE_TAG, "ESP_GATTS_EXEC_WRITE_EVT");
        if (p_data->exec_write.exec_write_flag)
        {
            print_write_buffer();
            free_write_buffer();
        }
        break;
    }
    case ESP_GATTS_MTU_EVT:
        spp_mtu_size = p_data->mtu.mtu;
        break;
    case ESP_GATTS_CONF_EVT:
        break;
    case ESP_GATTS_UNREG_EVT:
        break;
    case ESP_GATTS_DELETE_EVT:
        break;
    case ESP_GATTS_START_EVT:
        break;
    case ESP_GATTS_STOP_EVT:
        break;
    case ESP_GATTS_CONNECT_EVT:
        spp_conn_id = p_data->connect.conn_id;
        spp_gatts_if = gatts_if;
        is_connected = true;
        memcpy(&spp_remote_bda, &p_data->connect.remote_bda, sizeof(esp_bd_addr_t));
        ESP_LOGW(GATTS_TABLE_TAG, "ESP_GATTS_CONNECT_EVT conn_id %d, spp_gatts_if %d", spp_conn_id, spp_gatts_if);
#ifdef SUPPORT_HEARTBEAT
        uint16_t cmd = 0;
        xQueueSend(cmd_heartbeat_queue, &cmd, 10 / portTICK_PERIOD_MS);
#endif
        break;
    case ESP_GATTS_DISCONNECT_EVT:
        spp_mtu_size = 23;
        is_connected = false;
        enable_data_ntf = false;
#ifdef SUPPORT_HEARTBEAT
        enable_heart_ntf = false;
        heartbeat_count_num = 0;
#endif
        esp_ble_gap_start_advertising(&spp_adv_params);
        ESP_LOGW(GATTS_TABLE_TAG, "ESP_GATTS_DISCONNECT_EVT");
        break;
    case ESP_GATTS_OPEN_EVT:
        break;
    case ESP_GATTS_CANCEL_OPEN_EVT:
        break;
    case ESP_GATTS_CLOSE_EVT:
        break;
    case ESP_GATTS_LISTEN_EVT:
        break;
    case ESP_GATTS_CONGEST_EVT:
        break;
    case ESP_GATTS_CREAT_ATTR_TAB_EVT:
    {
        ESP_LOGI(GATTS_TABLE_TAG, "The number handle =%x", param->add_attr_tab.num_handle);
        if (param->add_attr_tab.status != ESP_GATT_OK)
        {
            ESP_LOGE(GATTS_TABLE_TAG, "Create attribute table failed, error code=0x%x", param->add_attr_tab.status);
        }
        else if (param->add_attr_tab.num_handle != SPP_IDX_NB)
        {
            ESP_LOGE(GATTS_TABLE_TAG, "Create attribute table abnormally, num_handle (%d) doesn't equal to HRS_IDX_NB(%d)", param->add_attr_tab.num_handle, SPP_IDX_NB);
        }
        else
        {
            memcpy(spp_handle_table, param->add_attr_tab.handles, sizeof(spp_handle_table));
            esp_ble_gatts_start_service(spp_handle_table[SPP_IDX_SVC]);
        }
        break;
    }
    default:
        break;
    }
}

static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param)
{
    ESP_LOGI(GATTS_TABLE_TAG, "EVT %d, gatts if %d", event, gatts_if);

    /* If event is register event, store the gatts_if for each profile */
    if (event == ESP_GATTS_REG_EVT)
    {
        if (param->reg.status == ESP_GATT_OK)
        {
            spp_profile_tab[SPP_PROFILE_APP_IDX].gatts_if = gatts_if;
        }
        else
        {
            ESP_LOGI(GATTS_TABLE_TAG, "Reg app failed, app_id %04x, status %d", param->reg.app_id, param->reg.status);
            return;
        }
    }

    do
    {
        int idx;
        for (idx = 0; idx < SPP_PROFILE_NUM; idx++)
        {
            if (gatts_if == ESP_GATT_IF_NONE || /* ESP_GATT_IF_NONE, not specify a certain gatt_if, need to call every profile cb function */
                gatts_if == spp_profile_tab[idx].gatts_if)
            {
                if (spp_profile_tab[idx].gatts_cb)
                {
                    spp_profile_tab[idx].gatts_cb(event, gatts_if, param);
                }
            }
        }
    } while (0);
}

void app_main(void)
{
    esp_err_t ret;
    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();

    // Initialize NVS
    ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND)
    {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);

    ESP_ERROR_CHECK(esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT));

    ret = esp_bt_controller_init(&bt_cfg);
    if (ret)
    {
        ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed: %s", __func__, esp_err_to_name(ret));
        return;
    }

    ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
    if (ret)
    {
        ESP_LOGE(GATTS_TABLE_TAG, "%s enable controller failed: %s", __func__, esp_err_to_name(ret));
        return;
    }

    ESP_LOGI(GATTS_TABLE_TAG, "%s init bluetooth", __func__);

    ret = esp_bluedroid_init();
    if (ret)
    {
        ESP_LOGE(GATTS_TABLE_TAG, "%s init bluetooth failed: %s", __func__, esp_err_to_name(ret));
        return;
    }
    ret = esp_bluedroid_enable();
    if (ret)
    {
        ESP_LOGE(GATTS_TABLE_TAG, "%s enable bluetooth failed: %s", __func__, esp_err_to_name(ret));
        return;
    }

    at_uart_init();

    while (is_entry_spp_mode != true)
    {
        vTaskDelay(10 / portTICK_PERIOD_MS);
    }

    vTaskDelay(10 / portTICK_PERIOD_MS);
    uart_driver_delete(UART_NUM_1);
    vTaskDelay(10 / portTICK_PERIOD_MS);

    ESP_LOGW(GATTS_TABLE_TAG, "ble entry spp mode");

    esp_ble_gatts_register_callback(gatts_event_handler);
    esp_ble_gap_register_callback(gap_event_handler);
    esp_ble_gatts_app_register(ESP_SPP_APP_ID);

    spp_task_init();

    esp_err_t local_mtu_ret = esp_ble_gatt_set_local_mtu(500);
    if (local_mtu_ret)
    {
        ESP_LOGE(GATTS_TABLE_TAG, "set local  MTU failed, error code = %x", local_mtu_ret);
    }

    return;
}
